/**
 * 聊天控制器
 * 处理用户聊天请求，整合AI服务和数据库操作
 */

const AIService = require('../services/aiService');
const DatabaseService = require('../services/databaseService');

class ChatController {
  constructor() {
    this.aiService = new AIService();
    this.dbService = new DatabaseService();
  }

  /**
   * 初始化控制器（连接数据库）
   */
  async initialize() {
    try {
      await this.dbService.connect();
      console.log('ChatController初始化成功');
    } catch (error) {
      console.error('ChatController初始化失败:', error.message);
      throw error;
    }
  }

  /**
   * 处理用户聊天消息
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async handleChatMessage(req, res) {
    try {
      const { message } = req.body;

      if (!message || message.trim() === '') {
        return res.status(400).json({
          success: false,
          error: '消息内容不能为空'
        });
      }

      console.log('收到用户消息:', message);

      // 1. 使用AI服务解析用户意图
      const aiResult = await this.aiService.parseUserIntent(message);

      if (!aiResult.success) {
        return res.json({
          success: false,
          error: aiResult.error,
          response: '抱歉，我无法理解您的请求，请尝试更清楚地描述您的需求。'
        });
      }

      const { action, data, conditions, response } = aiResult.data;

      // 2. 根据AI解析结果执行相应的数据库操作
      let operationResult;
      try {
        switch (action) {
          case 'insert':
            operationResult = await this.dbService.insertStudent(data);
            break;

          case 'select':
            operationResult = await this.dbService.selectStudents(conditions);
            break;

          case 'update':
            operationResult = await this.dbService.updateStudents(data, conditions);
            break;

          case 'delete':
            operationResult = await this.dbService.deleteStudents(conditions);
            break;

          default:
            throw new Error(`不支持的操作类型: ${action}`);
        }
      } catch (dbError) {
        console.error('数据库操作失败:', dbError.message);
        return res.json({
          success: false,
          error: dbError.message,
          response: `操作失败：${dbError.message}`
        });
      }

      // 3. 生成智能回复
      const smartReply = await this.aiService.generateSmartReply(message, operationResult);

      // 4. 返回结果
      res.json({
        success: true,
        action: action,
        result: operationResult,
        response: smartReply || response || '操作完成',
        originalMessage: message
      });

    } catch (error) {
      console.error('处理聊天消息时发生错误:', error.message);
      res.status(500).json({
        success: false,
        error: '服务器内部错误',
        response: '抱歉，处理您的请求时发生了错误，请稍后重试。'
      });
    }
  }

  /**
   * 获取所有学生数据
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async getAllStudents(req, res) {
    try {
      const result = await this.dbService.selectStudents();
      res.json(result);
    } catch (error) {
      console.error('获取学生数据失败:', error.message);
      res.status(500).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * 获取数据库统计信息
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async getStatistics(req, res) {
    try {
      const result = await this.dbService.getStatistics();
      res.json(result);
    } catch (error) {
      console.error('获取统计信息失败:', error.message);
      res.status(500).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * 重置聊天（清理资源）
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async resetChat(req, res) {
    try {
      // 这里可以添加清理逻辑，比如清理会话状态等
      res.json({
        success: true,
        message: '聊天已重置'
      });
    } catch (error) {
      console.error('重置聊天失败:', error.message);
      res.status(500).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * 健康检查
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async healthCheck(req, res) {
    try {
      // 检查数据库连接
      const stats = await this.dbService.getStatistics();

      res.json({
        success: true,
        status: 'healthy',
        timestamp: new Date().toISOString(),
        database: 'connected',
        totalStudents: stats.statistics.totalStudents
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        status: 'unhealthy',
        timestamp: new Date().toISOString(),
        error: error.message
      });
    }
  }

  /**
   * 手动添加学生
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async addStudent(req, res) {
    try {
      const { name, age, major } = req.body;

      if (!name || !age || !major) {
        return res.status(400).json({
          success: false,
          error: '缺少必要的学生信息',
          message: '请提供姓名、年龄和专业'
        });
      }

      // 验证数据类型
      if (typeof name !== 'string' || typeof major !== 'string') {
        return res.status(400).json({
          success: false,
          error: '数据类型错误',
          message: '姓名和专业必须是字符串'
        });
      }

      const ageNum = parseInt(age);
      if (isNaN(ageNum) || ageNum < 16 || ageNum > 100) {
        return res.status(400).json({
          success: false,
          error: '年龄数据无效',
          message: '年龄必须是16-100之间的数字'
        });
      }

      const result = await this.dbService.insertStudent({
        name: name.trim(),
        age: ageNum,
        major: major.trim()
      });

      res.json(result);
    } catch (error) {
      console.error('添加学生失败:', error.message);
      res.status(500).json({
        success: false,
        error: '添加学生失败',
        message: error.message
      });
    }
  }

  /**
   * 手动更新学生
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async updateStudent(req, res) {
    try {
      const studentId = parseInt(req.params.id);
      const { name, age, major } = req.body;

      if (isNaN(studentId)) {
        return res.status(400).json({
          success: false,
          error: '学生ID无效',
          message: '学生ID必须是数字'
        });
      }

      if (!name || !age || !major) {
        return res.status(400).json({
          success: false,
          error: '缺少必要的学生信息',
          message: '请提供姓名、年龄和专业'
        });
      }

      // 验证数据类型
      if (typeof name !== 'string' || typeof major !== 'string') {
        return res.status(400).json({
          success: false,
          error: '数据类型错误',
          message: '姓名和专业必须是字符串'
        });
      }

      const ageNum = parseInt(age);
      if (isNaN(ageNum) || ageNum < 16 || ageNum > 100) {
        return res.status(400).json({
          success: false,
          error: '年龄数据无效',
          message: '年龄必须是16-100之间的数字'
        });
      }

      const result = await this.dbService.updateStudents(
        {
          name: name.trim(),
          age: ageNum,
          major: major.trim()
        },
        { id: studentId }
      );

      res.json(result);
    } catch (error) {
      console.error('更新学生失败:', error.message);
      res.status(500).json({
        success: false,
        error: '更新学生失败',
        message: error.message
      });
    }
  }

  /**
   * 手动删除学生
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async deleteStudent(req, res) {
    try {
      const studentId = parseInt(req.params.id);

      if (isNaN(studentId)) {
        return res.status(400).json({
          success: false,
          error: '学生ID无效',
          message: '学生ID必须是数字'
        });
      }

      const result = await this.dbService.deleteStudents({ id: studentId });

      res.json(result);
    } catch (error) {
      console.error('删除学生失败:', error.message);
      res.status(500).json({
        success: false,
        error: '删除学生失败',
        message: error.message
      });
    }
  }

  /**
   * 导出学生数据为CSV格式
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   */
  async exportToCSV(req, res) {
    try {
      // 获取所有学生数据
      const studentsResult = await this.dbService.selectStudents();

      if (!studentsResult.success) {
        return res.status(500).json({
          success: false,
          error: '获取学生数据失败',
          message: studentsResult.error
        });
      }

      const students = studentsResult.students;

      // 构建CSV内容
      const csvHeader = '学号,姓名,年龄,专业,创建时间\n';
      const csvRows = students.map(student => {
        const createdAt = new Date(student.created_at).toLocaleString('zh-CN');
        return `${student.id},"${student.name}",${student.age},"${student.major}","${createdAt}"`;
      }).join('\n');

      const csvContent = csvHeader + csvRows;

      // 设置响应头
      const filename = `学生信息表_${new Date().toISOString().slice(0, 10)}.csv`;
      res.setHeader('Content-Type', 'text/csv; charset=utf-8');
      res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(filename)}"`);

      // 添加BOM以确保Excel正确显示中文
      res.write('\uFEFF');
      res.end(csvContent);

    } catch (error) {
      console.error('导出CSV失败:', error.message);
      res.status(500).json({
        success: false,
        error: '导出失败',
        message: error.message
      });
    }
  }
}

module.exports = ChatController;